package com.example.financeapi.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.example.financeapi.entity.vo.ResultVo;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.reflect.TypeToken;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Title: JsonUtils.java
 * @Package com.lee.utils
 * @Description: 自定义响应结构, 转换类
 */
public class JsonUtils {

    // 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();

    /**
     * 将对象转换成json字符串。
     * <p>Title: pojoToJson</p>
     * <p>Description: </p>
     * @param data
     * @return
     */
    public static String objectToJson(Object data) {
    	try {
			String string = MAPPER.writeValueAsString(data);
			return string;
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
    	return null;
    }

    /**
     * 将对象转换成json字符串。
     * @param obj
     * @return
     */
    public static String toJson(Object obj) {
        Gson gson = new GsonBuilder()
                .setPrettyPrinting()
                .create();
        return gson.toJson(obj);
    }

    /**
     * 将对象转换成json字符串。为NULL也展示
     * @param obj
     * @return
     */
    public static String toJsonTwo(Object obj) {
        Gson gson = new GsonBuilder()
                .setPrettyPrinting()
                .serializeNulls()
                .create();
        return gson.toJson(obj);
    }
    
    /**
     * jackson: 将json结果集转化为对象
     * 
     * @param jsonData json数据
     * @param beanType 对象中的object类型
     * @return
     */
    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
        	e.printStackTrace();
        }
        return null;
    }

    /**
     * Gson: 将json结果集转化为对象
     * @param json
     * @param clz
     * @param <T>
     * @return
     */
    public static <T> T jsonToObj(String json,Class<T> clz){
        return new Gson().fromJson(json,clz);
    }

    /**
     * fastjson: 将json字符串转换成对象
     * @param json
     * @param clazz
     * @return
     */
    public static <T> T jsonToBean(String json, Class<T> clazz) {
        return JSON.parseObject(json, clazz);
    }

    /**
     * fastjson: 将json字符串转换成对象
     * @param json
     * @param clazz
     * @return
     */
    public static <T> T jsonToBeanTwo(String json, Class<T> clazz) {
        return JSONObject.parseObject(json, clazz);
    }
    
    /**
     * 将json数据转换成pojo对象list
     * <p>Title: jsonToList</p>
     * <p>Description: </p>
     * @param jsonData
     * @param beanType
     * @return
     */
    public static <T>List<T> jsonToList(String jsonData, Class<T> beanType) {
    	JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
    	try {
    		List<T> list = MAPPER.readValue(jsonData, javaType);
    		return list;
		} catch (Exception e) {
			e.printStackTrace();
		}
    	return null;
    }

    /**
     * json 转 List<T>
     * @param jsonStr
     * @param tClass
     * @param <T>
     * @return
     */
    public static <T> List<T> jsonToListTwo(String jsonStr, Class<T> tClass) {
        return JSONArray.parseArray(jsonStr, tClass);
    }

    /**
     * List<T> 转 json
     * @param ts
     * @param <T>
     * @return
     */
    public static <T> String listToJson(List<T> ts){
        return JSON.toJSONString(ts);
    }

    /**
     * json 转 Map
     * @param json
     * @return
     */
    public static Map<String, Object> jsonToMap(String json){
        Gson gson=new Gson();
        Map<String, Object> map = gson.fromJson(json, new TypeToken<Map<String,Object>>(){}.getType());
        return map;
    }

    /**
     * json 转 Map
     * @param json
     * @return
     */
    public static Map<String,String> jsonToMapStr(String json) {
        Gson gson=new Gson();
        Map<String, JsonObject> map = gson.fromJson(json, new TypeToken<Map<String,JsonObject>>(){}.getType());
        Map<String,String> result = new HashMap<>();
        for(String key:map.keySet()){
            result.put(key,gson.fromJson(map.get(key),String.class) );
        }
        return result;
    }


    public static void main(String[] args) {
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("name", "mafly");
        map.put("age", "18");
        map.put("sex", null);

        String jsonString = new Gson().toJson(map);
        String jsonString2 = toJson(map);
        String jsonString3 = toJsonTwo(map);

        String jsonStr = "{\"msg\":\"王五\",\"data\":\"124掉高德\"}";
        ResultVo r1 =jsonToBean(jsonStr,ResultVo.class);
        ResultVo r2 =jsonToBeanTwo(jsonStr,ResultVo.class);

        System.err.println(toJson(r1));
        System.err.println(toJson(r2));
        System.err.println(jsonString);
        System.err.println(jsonString2);
        System.err.println(jsonString3);

    }

}
